+2000-12-13 Havoc Pennington <hp@pobox.com>
+
+ * gtk/gtktextbtree.h: Put _ in front of every function in this
+ header file
+
+ * gtk/gtktext*.[hc]: update to reflect renamed btree functions
+
2000-12-13 <alexl@redhat.com>
* gdk/linux-fb/gdkmouse-fb.c (mouse_devs):
+2000-12-13 Havoc Pennington <hp@pobox.com>
+
+ * gtk/gtktextbtree.h: Put _ in front of every function in this
+ header file
+
+ * gtk/gtktext*.[hc]: update to reflect renamed btree functions
+
2000-12-13 <alexl@redhat.com>
* gdk/linux-fb/gdkmouse-fb.c (mouse_devs):
+2000-12-13 Havoc Pennington <hp@pobox.com>
+
+ * gtk/gtktextbtree.h: Put _ in front of every function in this
+ header file
+
+ * gtk/gtktext*.[hc]: update to reflect renamed btree functions
+
2000-12-13 <alexl@redhat.com>
* gdk/linux-fb/gdkmouse-fb.c (mouse_devs):
+2000-12-13 Havoc Pennington <hp@pobox.com>
+
+ * gtk/gtktextbtree.h: Put _ in front of every function in this
+ header file
+
+ * gtk/gtktext*.[hc]: update to reflect renamed btree functions
+
2000-12-13 <alexl@redhat.com>
* gdk/linux-fb/gdkmouse-fb.c (mouse_devs):
+2000-12-13 Havoc Pennington <hp@pobox.com>
+
+ * gtk/gtktextbtree.h: Put _ in front of every function in this
+ header file
+
+ * gtk/gtktext*.[hc]: update to reflect renamed btree functions
+
2000-12-13 <alexl@redhat.com>
* gdk/linux-fb/gdkmouse-fb.c (mouse_devs):
+2000-12-13 Havoc Pennington <hp@pobox.com>
+
+ * gtk/gtktextbtree.h: Put _ in front of every function in this
+ header file
+
+ * gtk/gtktext*.[hc]: update to reflect renamed btree functions
+
2000-12-13 <alexl@redhat.com>
* gdk/linux-fb/gdkmouse-fb.c (mouse_devs):
+2000-12-13 Havoc Pennington <hp@pobox.com>
+
+ * gtk/gtktextbtree.h: Put _ in front of every function in this
+ header file
+
+ * gtk/gtktext*.[hc]: update to reflect renamed btree functions
+
2000-12-13 <alexl@redhat.com>
* gdk/linux-fb/gdkmouse-fb.c (mouse_devs):
/*
* The structure below is used to pass information between
- * gtk_text_btree_get_tags and inc_count:
+ * _gtk_text_btree_get_tags and inc_count:
*/
typedef struct TagInfo {
*/
GtkTextBTree*
-gtk_text_btree_new (GtkTextTagTable *table,
+_gtk_text_btree_new (GtkTextTagTable *table,
GtkTextBuffer *buffer)
{
GtkTextBTree *tree;
GtkTextIter start;
GtkTextLineSegment *seg;
- gtk_text_btree_get_iter_at_line_char (tree, &start, 0, 0);
+ __gtk_text_btree_get_iter_at_line_char (tree, &start, 0, 0);
- tree->insert_mark = gtk_text_btree_set_mark (tree,
+ tree->insert_mark = _gtk_text_btree_set_mark (tree,
NULL,
"insert",
FALSE,
seg->body.mark.not_deleteable = TRUE;
seg->body.mark.visible = TRUE;
- tree->selection_bound_mark = gtk_text_btree_set_mark (tree,
+ tree->selection_bound_mark = _gtk_text_btree_set_mark (tree,
NULL,
"selection_bound",
FALSE,
}
void
-gtk_text_btree_ref (GtkTextBTree *tree)
+_gtk_text_btree_ref (GtkTextBTree *tree)
{
g_return_if_fail (tree != NULL);
g_return_if_fail (tree->refcount > 0);
}
void
-gtk_text_btree_unref (GtkTextBTree *tree)
+_gtk_text_btree_unref (GtkTextBTree *tree)
{
g_return_if_fail (tree != NULL);
g_return_if_fail (tree->refcount > 0);
}
GtkTextBuffer*
-gtk_text_btree_get_buffer (GtkTextBTree *tree)
+_gtk_text_btree_get_buffer (GtkTextBTree *tree)
{
return tree->buffer;
}
guint
-gtk_text_btree_get_chars_changed_stamp (GtkTextBTree *tree)
+_gtk_text_btree_get_chars_changed_stamp (GtkTextBTree *tree)
{
return tree->chars_changed_stamp;
}
guint
-gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree)
+_gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree)
{
return tree->segments_changed_stamp;
}
void
-gtk_text_btree_segments_changed (GtkTextBTree *tree)
+_gtk_text_btree_segments_changed (GtkTextBTree *tree)
{
g_return_if_fail (tree != NULL);
segments_changed (tree);
*/
void
-gtk_text_btree_delete (GtkTextIter *start,
+_gtk_text_btree_delete (GtkTextIter *start,
GtkTextIter *end)
{
GtkTextLineSegment *prev_seg; /* The segment just before the start
line1 = gtk_text_iter_get_line (start);
line2 = gtk_text_iter_get_line (end);
- if (line2 == gtk_text_btree_line_count (tree))
+ if (line2 == _gtk_text_btree_line_count (tree))
{
GtkTextTag** tags;
int array_size;
--line1;
}
- tags = gtk_text_btree_get_tags (end,
+ tags = _gtk_text_btree_get_tags (end,
&array_size);
if (tags != NULL)
i = 0;
while (i < array_size)
{
- gtk_text_btree_tag (end, &orig_end, tags[i], FALSE);
+ _gtk_text_btree_tag (end, &orig_end, tags[i], FALSE);
++i;
}
}
/* Broadcast the need for redisplay before we break the iterators */
- gtk_text_btree_invalidate_region (tree, start, end);
+ _gtk_text_btree_invalidate_region (tree, start, end);
/* Save the byte offset so we can reset the iterators */
start_byte_offset = gtk_text_iter_get_line_index (start);
* (unless it's the starting line for the range).
*/
- nextline = gtk_text_line_next (curline);
+ nextline = _gtk_text_line_next (curline);
if (curline != start_line)
{
if (curnode == start_line->parent)
while (line)
{
GtkTextLine *next_line = line->next;
- ld = gtk_text_line_get_data (line, view->view_id);
+ ld = _gtk_text_line_get_data (line, view->view_id);
if (ld)
{
if (deleted_width > 0 || deleted_height > 0)
{
- ld = gtk_text_line_get_data (start_line, view->view_id);
+ ld = _gtk_text_line_get_data (start_line, view->view_id);
/* FIXME: ld is _NOT_ necessarily non-null here, but there is currently
* no way to add ld without also validating the node, which would
segments_changed (tree);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
/* Re-initialize our iterators */
- gtk_text_btree_get_iter_at_line (tree, start, start_line, start_byte_offset);
+ _gtk_text_btree_get_iter_at_line (tree, start, start_line, start_byte_offset);
*end = *start;
}
void
-gtk_text_btree_insert (GtkTextIter *iter,
+_gtk_text_btree_insert (GtkTextIter *iter,
const gchar *text,
gint len)
{
GtkTextIter end;
- gtk_text_btree_get_iter_at_line (tree,
+ _gtk_text_btree_get_iter_at_line (tree,
&start,
start_line,
start_byte_index);
above. FIXME */
gtk_text_iter_forward_chars (&end, char_count_delta);
- gtk_text_btree_invalidate_region (tree,
+ _gtk_text_btree_invalidate_region (tree,
&start, &end);
/* reset *iter for the user, and invalidate tree nodes */
- gtk_text_btree_get_iter_at_line (tree, &start, line, start_byte_offset);
+ _gtk_text_btree_get_iter_at_line (tree, &start, line, start_byte_offset);
*iter = start;
gtk_text_iter_forward_char (iter); /* skip forward past the segment */
- gtk_text_btree_invalidate_region (tree, &start, iter);
+ _gtk_text_btree_invalidate_region (tree, &start, iter);
}
void
-gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
+__gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
GdkPixbuf *pixbuf)
{
GtkTextLineSegment *seg;
}
GtkTextChildAnchor*
-gtk_text_btree_create_child_anchor (GtkTextIter *iter)
+_gtk_text_btree_create_child_anchor (GtkTextIter *iter)
{
GtkTextLineSegment *seg;
GtkTextBTree *tree;
}
void
-gtk_text_btree_unregister_child_anchor (GtkTextChildAnchor *anchor)
+_gtk_text_btree_unregister_child_anchor (GtkTextChildAnchor *anchor)
{
GtkTextLineSegment *seg;
gint current_y = 0;
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
if (node->level == 0)
{
{
GtkTextLineData *ld;
- ld = gtk_text_line_get_data (line, view->view_id);
+ ld = _gtk_text_line_get_data (line, view->view_id);
if (ld)
{
}
GtkTextLine *
-gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
+_gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
gpointer view_id,
gint ypixel,
gint *line_top_out)
if (line == target_line)
return y;
- ld = gtk_text_line_get_data (line, view->view_id);
+ ld = _gtk_text_line_get_data (line, view->view_id);
if (ld)
y += ld->height;
}
gint
-gtk_text_btree_find_line_top (GtkTextBTree *tree,
+_gtk_text_btree_find_line_top (GtkTextBTree *tree,
GtkTextLine *target_line,
gpointer view_id)
{
}
void
-gtk_text_btree_add_view (GtkTextBTree *tree,
+_gtk_text_btree_add_view (GtkTextBTree *tree,
GtkTextLayout *layout)
{
BTreeView *view;
line_data->height = 0;
line_data->valid = TRUE;
- gtk_text_line_add_data (last_line, line_data);
+ _gtk_text_line_add_data (last_line, line_data);
}
void
-gtk_text_btree_remove_view (GtkTextBTree *tree,
+_gtk_text_btree_remove_view (GtkTextBTree *tree,
gpointer view_id)
{
BTreeView *view;
* (Do this first, so that we don't try to call the view's line data destructor on it.)
*/
last_line = get_last_line (tree);
- line_data = gtk_text_line_remove_data (last_line, view_id);
+ line_data = _gtk_text_line_remove_data (last_line, view_id);
g_free (line_data);
gtk_text_btree_node_remove_view (view, tree->root_node, view_id);
}
void
-gtk_text_btree_invalidate_region (GtkTextBTree *tree,
+_gtk_text_btree_invalidate_region (GtkTextBTree *tree,
const GtkTextIter *start,
const GtkTextIter *end)
{
}
void
-gtk_text_btree_get_view_size (GtkTextBTree *tree,
+_gtk_text_btree_get_view_size (GtkTextBTree *tree,
gpointer view_id,
gint *width,
gint *height)
{
if (gtk_text_tag_affects_size (tag))
{
- gtk_text_btree_invalidate_region (tree, start, end);
+ _gtk_text_btree_invalidate_region (tree, start, end);
}
else if (gtk_text_tag_affects_nonsize_appearance (tag))
}
void
-gtk_text_btree_tag (const GtkTextIter *start_orig,
+_gtk_text_btree_tag (const GtkTextIter *start_orig,
const GtkTextIter *end_orig,
GtkTextTag *tag,
gboolean add)
segments_changed (tree);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
}
*/
GtkTextLine*
-gtk_text_btree_get_line (GtkTextBTree *tree,
+_gtk_text_btree_get_line (GtkTextBTree *tree,
gint line_number,
gint *real_line_number)
{
int lines_left;
int line_count;
- line_count = gtk_text_btree_line_count (tree);
+ line_count = _gtk_text_btree_line_count (tree);
if (line_number < 0)
{
}
GtkTextLine*
-gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
+__gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
gint char_index,
gint *line_start_index,
gint *real_char_index)
}
GtkTextTag**
-gtk_text_btree_get_tags (const GtkTextIter *iter,
+_gtk_text_btree_get_tags (const GtkTextIter *iter,
gint *num_tags)
{
GtkTextBTreeNode *node;
/* Don't copy if we're invisible; segments are invisible/not
as a whole, no need to check each char */
if (!include_hidden &&
- gtk_text_btree_char_is_invisible (start))
+ _gtk_text_btree_char_is_invisible (start))
{
copy = FALSE;
/* printf (" <invisible>\n"); */
copy = FALSE;
}
else if (!include_hidden &&
- gtk_text_btree_char_is_invisible (start))
+ _gtk_text_btree_char_is_invisible (start))
{
copy = FALSE;
}
}
gchar*
-gtk_text_btree_get_text (const GtkTextIter *start_orig,
+_gtk_text_btree_get_text (const GtkTextIter *start_orig,
const GtkTextIter *end_orig,
gboolean include_hidden,
gboolean include_nonchars)
}
gint
-gtk_text_btree_line_count (GtkTextBTree *tree)
+_gtk_text_btree_line_count (GtkTextBTree *tree)
{
/* Subtract bogus line at the end; we return a count
of usable lines. */
}
gint
-gtk_text_btree_char_count (GtkTextBTree *tree)
+_gtk_text_btree_char_count (GtkTextBTree *tree)
{
/* Exclude newline in bogus last line */
return tree->root_node->num_chars - 1;
#define LOTSA_TAGS 1000
gboolean
-gtk_text_btree_char_is_invisible (const GtkTextIter *iter)
+_gtk_text_btree_char_is_invisible (const GtkTextIter *iter)
{
gboolean invisible = FALSE; /* if nobody says otherwise, it's visible */
gint start_y, end_y;
GtkTextLineData *ld;
- start_y = gtk_text_btree_find_line_top (tree, start_line, view->view_id);
+ start_y = _gtk_text_btree_find_line_top (tree, start_line, view->view_id);
if (end_line == start_line)
end_y = start_y;
else
- end_y = gtk_text_btree_find_line_top (tree, end_line, view->view_id);
+ end_y = _gtk_text_btree_find_line_top (tree, end_line, view->view_id);
- ld = gtk_text_line_get_data (end_line, view->view_id);
+ ld = _gtk_text_line_get_data (end_line, view->view_id);
if (ld)
end_y += ld->height;
GtkTextIter iter;
GtkTextIter end;
- gtk_text_btree_get_iter_at_mark (mark->body.mark.tree,
+ _gtk_text_btree_get_iter_at_mark (mark->body.mark.tree,
&iter,
mark->body.mark.obj);
end = iter;
gtk_text_iter_forward_char (&end);
- gtk_text_btree_invalidate_region (mark->body.mark.tree,
+ _gtk_text_btree_invalidate_region (mark->body.mark.tree,
&iter, &end);
}
GtkTextIter *iter)
{
if (gtk_text_iter_get_line (iter) ==
- gtk_text_btree_line_count (tree))
+ _gtk_text_btree_line_count (tree))
gtk_text_iter_backward_char (iter);
}
{
GtkTextIter old_pos;
- gtk_text_btree_get_iter_at_mark (tree, &old_pos,
+ _gtk_text_btree_get_iter_at_mark (tree, &old_pos,
mark->body.mark.obj);
redisplay_region (tree, &old_pos, where);
}
gtk_text_iter_check (&iter);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
return mark;
}
GtkTextMark*
-gtk_text_btree_set_mark (GtkTextBTree *tree,
+_gtk_text_btree_set_mark (GtkTextBTree *tree,
GtkTextMark *existing_mark,
const gchar *name,
gboolean left_gravity,
}
gboolean
-gtk_text_btree_get_selection_bounds (GtkTextBTree *tree,
+_gtk_text_btree_get_selection_bounds (GtkTextBTree *tree,
GtkTextIter *start,
GtkTextIter *end)
{
GtkTextIter tmp_start, tmp_end;
- gtk_text_btree_get_iter_at_mark (tree, &tmp_start,
+ _gtk_text_btree_get_iter_at_mark (tree, &tmp_start,
tree->insert_mark);
- gtk_text_btree_get_iter_at_mark (tree, &tmp_end,
+ _gtk_text_btree_get_iter_at_mark (tree, &tmp_end,
tree->selection_bound_mark);
if (gtk_text_iter_equal (&tmp_start, &tmp_end))
}
void
-gtk_text_btree_place_cursor (GtkTextBTree *tree,
+_gtk_text_btree_place_cursor (GtkTextBTree *tree,
const GtkTextIter *iter)
{
GtkTextIter start, end;
- if (gtk_text_btree_get_selection_bounds (tree, &start, &end))
+ if (_gtk_text_btree_get_selection_bounds (tree, &start, &end))
redisplay_region (tree, &start, &end);
/* Move insert AND selection_bound before we redisplay */
}
void
-gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
+__gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
const gchar *name)
{
GtkTextMark *mark;
mark = g_hash_table_lookup (tree->mark_table,
name);
- gtk_text_btree_remove_mark (tree, mark);
+ _gtk_text_btree_remove_mark (tree, mark);
}
void
-gtk_text_btree_remove_mark (GtkTextBTree *tree,
+_gtk_text_btree_remove_mark (GtkTextBTree *tree,
GtkTextMark *mark)
{
GtkTextLineSegment *segment;
}
gboolean
-gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
+_gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
GtkTextMark *segment)
{
return segment == tree->insert_mark;
}
gboolean
-gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
+_gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
GtkTextMark *segment)
{
return segment == tree->selection_bound_mark;
}
GtkTextMark*
-gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
+_gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
const gchar *name)
{
GtkTextLineSegment *seg;
}
GtkTextLine*
-gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
+_gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
GtkTextTag *tag)
{
GtkTextBTreeNode *node;
Unfortunately this can't be done in a simple and efficient way
right now; so I'm just going to return the
first line in the btree. FIXME */
- return gtk_text_btree_get_line (tree, 0, NULL);
+ return _gtk_text_btree_get_line (tree, 0, NULL);
}
}
GtkTextLine*
-gtk_text_btree_last_could_contain_tag (GtkTextBTree *tree,
+_gtk_text_btree_last_could_contain_tag (GtkTextBTree *tree,
GtkTextTag *tag)
{
GtkTextBTreeNode *node;
at least not without complexity.
So, we just return the last line.
*/
- return gtk_text_btree_get_line (tree, -1, NULL);
+ return _gtk_text_btree_get_line (tree, -1, NULL);
}
}
*/
gint
-gtk_text_line_get_number (GtkTextLine *line)
+_gtk_text_line_get_number (GtkTextLine *line)
{
GtkTextLine *line2;
GtkTextBTreeNode *node, *parent, *node2;
/* FIXME this function is far too slow, for no good reason. */
gboolean
-gtk_text_line_char_has_tag (GtkTextLine *line,
+_gtk_text_line_char_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
gint char_in_line,
GtkTextTag *tag)
}
gboolean
-gtk_text_line_byte_has_tag (GtkTextLine *line,
+_gtk_text_line_byte_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
gint byte_in_line,
GtkTextTag *tag)
}
gboolean
-gtk_text_line_is_last (GtkTextLine *line,
+_gtk_text_line_is_last (GtkTextLine *line,
GtkTextBTree *tree)
{
return line == get_last_line (tree);
}
GtkTextLine*
-gtk_text_line_next (GtkTextLine *line)
+_gtk_text_line_next (GtkTextLine *line)
{
GtkTextBTreeNode *node;
}
GtkTextLine*
-gtk_text_line_previous (GtkTextLine *line)
+_gtk_text_line_previous (GtkTextLine *line)
{
GtkTextBTreeNode *node;
GtkTextBTreeNode *node2;
}
void
-gtk_text_line_add_data (GtkTextLine *line,
+_gtk_text_line_add_data (GtkTextLine *line,
GtkTextLineData *data)
{
g_return_if_fail (line != NULL);
}
gpointer
-gtk_text_line_remove_data (GtkTextLine *line,
+_gtk_text_line_remove_data (GtkTextLine *line,
gpointer view_id)
{
GtkTextLineData *prev;
}
gpointer
-gtk_text_line_get_data (GtkTextLine *line,
+_gtk_text_line_get_data (GtkTextLine *line,
gpointer view_id)
{
GtkTextLineData *iter;
}
void
-gtk_text_line_invalidate_wrap (GtkTextLine *line,
+_gtk_text_line_invalidate_wrap (GtkTextLine *line,
GtkTextLineData *ld)
{
/* For now this is totally unoptimized. FIXME?
}
gint
-gtk_text_line_char_count (GtkTextLine *line)
+_gtk_text_line_char_count (GtkTextLine *line)
{
GtkTextLineSegment *seg;
gint size;
}
gint
-gtk_text_line_byte_count (GtkTextLine *line)
+_gtk_text_line_byte_count (GtkTextLine *line)
{
GtkTextLineSegment *seg;
gint size;
}
gint
-gtk_text_line_char_index (GtkTextLine *target_line)
+_gtk_text_line_char_index (GtkTextLine *target_line)
{
GSList *node_stack = NULL;
GtkTextBTreeNode *iter;
{
g_assert (line != NULL);
- num_chars += gtk_text_line_char_count (line);
+ num_chars += _gtk_text_line_char_count (line);
line = line->next;
}
}
GtkTextLineSegment*
-gtk_text_line_byte_to_segment (GtkTextLine *line,
+_gtk_text_line_byte_to_segment (GtkTextLine *line,
gint byte_offset,
gint *seg_offset)
{
}
GtkTextLineSegment*
-gtk_text_line_char_to_segment (GtkTextLine *line,
+_gtk_text_line_char_to_segment (GtkTextLine *line,
gint char_offset,
gint *seg_offset)
{
}
GtkTextLineSegment*
-gtk_text_line_byte_to_any_segment (GtkTextLine *line,
+_gtk_text_line_byte_to_any_segment (GtkTextLine *line,
gint byte_offset,
gint *seg_offset)
{
}
GtkTextLineSegment*
-gtk_text_line_char_to_any_segment (GtkTextLine *line,
+_gtk_text_line_char_to_any_segment (GtkTextLine *line,
gint char_offset,
gint *seg_offset)
{
}
gint
-gtk_text_line_byte_to_char (GtkTextLine *line,
+_gtk_text_line_byte_to_char (GtkTextLine *line,
gint byte_offset)
{
gint char_offset;
}
gint
-gtk_text_line_char_to_byte (GtkTextLine *line,
+_gtk_text_line_char_to_byte (GtkTextLine *line,
gint char_offset)
{
g_warning ("FIXME not implemented");
/* FIXME sync with char_locate (or figure out a clean
way to merge the two functions) */
void
-gtk_text_line_byte_locate (GtkTextLine *line,
+_gtk_text_line_byte_locate (GtkTextLine *line,
gint byte_offset,
GtkTextLineSegment **segment,
GtkTextLineSegment **any_segment,
/* FIXME sync with byte_locate (or figure out a clean
way to merge the two functions) */
void
-gtk_text_line_char_locate (GtkTextLine *line,
+_gtk_text_line_char_locate (GtkTextLine *line,
gint char_offset,
GtkTextLineSegment **segment,
GtkTextLineSegment **any_segment,
}
void
-gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
+__gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
gint byte_offset,
gint *line_char_offset,
gint *seg_char_offset)
}
void
-gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
+__gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
gint char_offset,
gint *line_byte_offset,
gint *seg_byte_offset)
/* remember that tag == NULL means "any tag" */
GtkTextLine*
-gtk_text_line_next_could_contain_tag (GtkTextLine *line,
+__gtk_text_line_next_could_contain_tag (GtkTextLine *line,
GtkTextBTree *tree,
GtkTextTag *tag)
{
g_return_val_if_fail (line != NULL, NULL);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
if (tag == NULL)
{
/* Right now we can only offer linear-search if the user wants
* to know about any tag toggle at all.
*/
- return gtk_text_line_next (line);
+ return _gtk_text_line_next (line);
}
/* Our tag summaries only have node precision, not line
}
GtkTextLine*
-gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
+__gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
GtkTextBTree *tree,
GtkTextTag *tag)
{
g_return_val_if_fail (line != NULL, NULL);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
if (tag == NULL)
{
/* Right now we can only offer linear-search if the user wants
* to know about any tag toggle at all.
*/
- return gtk_text_line_previous (line);
+ return _gtk_text_line_previous (line);
}
/* Return same-node line, if any. */
GtkTextLine *line;
gint real_line;
- n_lines = gtk_text_btree_line_count (tree);
+ n_lines = _gtk_text_btree_line_count (tree);
g_assert (n_lines >= 1); /* num_lines doesn't return bogus last line. */
- line = gtk_text_btree_get_line (tree, n_lines, &real_line);
+ line = _gtk_text_btree_get_line (tree, n_lines, &real_line);
tree->end_iter_line_stamp = tree->chars_changed_stamp;
tree->end_iter_line = line;
/**
- * gtk_text_btree_is_valid:
+ * _gtk_text_btree_is_valid:
* @tree: a #GtkTextBTree
* @view_id: ID for the view
*
* Return value: %TRUE if the entire #GtkTextBTree is valid
**/
gboolean
-gtk_text_btree_is_valid (GtkTextBTree *tree,
+_gtk_text_btree_is_valid (GtkTextBTree *tree,
gpointer view_id)
{
NodeData *nd;
/* Iterate over leading valid lines */
while (line != NULL)
{
- ld = gtk_text_line_get_data (line, view_id);
+ ld = _gtk_text_line_get_data (line, view_id);
if (!ld || !ld->valid)
break;
/* Iterate over invalid lines */
while (line != NULL)
{
- ld = gtk_text_line_get_data (line, view_id);
+ ld = _gtk_text_line_get_data (line, view_id);
if (ld && ld->valid)
break;
/* Iterate over the remaining lines */
while (line != NULL)
{
- ld = gtk_text_line_get_data (line, view_id);
+ ld = _gtk_text_line_get_data (line, view_id);
state->in_validation = FALSE;
if (!ld || !ld->valid)
}
/**
- * gtk_text_btree_validate:
+ * _gtk_text_btree_validate:
* @tree: a #GtkTextBTree
* @view_id: view id
* @max_pixels: the maximum number of pixels to validate. (No more
* entire tree was already valid.
**/
gboolean
-gtk_text_btree_validate (GtkTextBTree *tree,
+_gtk_text_btree_validate (GtkTextBTree *tree,
gpointer view_id,
gint max_pixels,
gint *y,
view = gtk_text_btree_get_view (tree, view_id);
g_return_val_if_fail (view != NULL, FALSE);
- if (!gtk_text_btree_is_valid (tree, view_id))
+ if (!_gtk_text_btree_is_valid (tree, view_id))
{
ValidateState state;
*new_height = state.new_height;
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
return TRUE;
}
while (line != NULL)
{
- GtkTextLineData *ld = gtk_text_line_get_data (line, view_id);
+ GtkTextLineData *ld = _gtk_text_line_get_data (line, view_id);
if (!ld || !ld->valid)
valid = FALSE;
/**
- * gtk_text_btree_validate_line:
+ * __gtk_text_btree_validate_line:
* @tree: a #GtkTextBTree
* @line: line to validate
* @view_id: view ID for the view to validate
* results up through the entire tree.
**/
void
-gtk_text_btree_validate_line (GtkTextBTree *tree,
+__gtk_text_btree_validate_line (GtkTextBTree *tree,
GtkTextLine *line,
gpointer view_id)
{
view = gtk_text_btree_get_view (tree, view_id);
g_return_if_fail (view != NULL);
- ld = gtk_text_line_get_data (line, view_id);
+ ld = _gtk_text_line_get_data (line, view_id);
if (!ld || !ld->valid)
{
ld = gtk_text_layout_wrap (view->layout, line, ld);
{
GtkTextLineData *ld;
- ld = gtk_text_line_remove_data (line, view_id);
+ ld = _gtk_text_line_remove_data (line, view_id);
if (ld)
gtk_text_layout_free_line_data (view->layout, line, ld);
GtkTextIter *start,
GtkTextIter *end)
{
- gtk_text_btree_get_iter_at_line_char (tree, start, 0, 0);
- gtk_text_btree_get_last_iter (tree, end);
+ __gtk_text_btree_get_iter_at_line_char (tree, start, 0, 0);
+ _gtk_text_btree_get_last_iter (tree, end);
}
static void
GtkTextIter start;
GtkTextIter end;
- if (gtk_text_btree_get_iter_at_first_toggle (tree, &start, tag))
+ if (_gtk_text_btree_get_iter_at_first_toggle (tree, &start, tag))
{
/* Must be a last toggle if there was a first one. */
- gtk_text_btree_get_iter_at_last_toggle (tree, &end, tag);
- gtk_text_btree_invalidate_region (tree,
+ _gtk_text_btree_get_iter_at_last_toggle (tree, &end, tag);
+ _gtk_text_btree_invalidate_region (tree,
&start, &end);
}
{
gint width, height;
- gtk_text_btree_get_view_size (tree, view->view_id, &width, &height);
+ _gtk_text_btree_get_view_size (tree, view->view_id, &width, &height);
gtk_text_layout_changed (view->layout, 0, height, height);
view = view->next;
get_tree_bounds (tree, &start, &end);
- gtk_text_btree_tag (&start, &end, tag, FALSE);
+ _gtk_text_btree_tag (&start, &end, tag, FALSE);
gtk_text_btree_remove_tag_info (tree, tag);
}
}
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
}
static GtkTextTagInfo*
*
* inc_count --
*
- * This is a utility procedure used by gtk_text_btree_get_tags. It
+ * This is a utility procedure used by _gtk_text_btree_get_tags. It
* increments the count for a particular tag, adding a new
* entry for that tag if there wasn't one previously.
*
segments_changed (tree);
if (gtk_debug_flags & GTK_DEBUG_TEXT)
- gtk_text_btree_check (tree);
+ _gtk_text_btree_check (tree);
}
static void
}
void
-gtk_text_btree_check (GtkTextBTree *tree)
+_gtk_text_btree_check (GtkTextBTree *tree)
{
Summary *summary;
GtkTextBTreeNode *node;
{
if (info->toggle_count != 0)
{
- g_error ("gtk_text_btree_check found \"%s\" with toggles (%d) but no root",
+ g_error ("_gtk_text_btree_check found \"%s\" with toggles (%d) but no root",
tag->name, info->toggle_count);
}
continue; /* no ranges for the tag */
}
else if (info->toggle_count == 0)
{
- g_error ("gtk_text_btree_check found root for \"%s\" with no toggles",
+ g_error ("_gtk_text_btree_check found root for \"%s\" with no toggles",
tag->name);
}
else if (info->toggle_count & 1)
{
- g_error ("gtk_text_btree_check found odd toggle count for \"%s\" (%d)",
+ g_error ("_gtk_text_btree_check found odd toggle count for \"%s\" (%d)",
tag->name, info->toggle_count);
}
for (summary = node->summary; summary != NULL;
{
if (summary->info->tag == tag)
{
- g_error ("gtk_text_btree_check found root GtkTextBTreeNode with summary info");
+ g_error ("_gtk_text_btree_check found root GtkTextBTreeNode with summary info");
}
}
count = 0;
}
if (count != info->toggle_count)
{
- g_error ("gtk_text_btree_check toggle_count (%d) wrong for \"%s\" should be (%d)",
+ g_error ("_gtk_text_btree_check toggle_count (%d) wrong for \"%s\" should be (%d)",
info->toggle_count, tag->name, count);
}
}
if (node->num_lines < 2)
{
- g_error ("gtk_text_btree_check: less than 2 lines in tree");
+ g_error ("_gtk_text_btree_check: less than 2 lines in tree");
}
if (node->num_chars < 2)
{
- g_error ("gtk_text_btree_check: less than 2 chars in tree");
+ g_error ("_gtk_text_btree_check: less than 2 chars in tree");
}
while (node->level > 0)
{
}
if (seg->type != >k_text_char_type)
{
- g_error ("gtk_text_btree_check: last line has bogus segment type");
+ g_error ("_gtk_text_btree_check: last line has bogus segment type");
}
if (seg->next != NULL)
{
- g_error ("gtk_text_btree_check: last line has too many segments");
+ g_error ("_gtk_text_btree_check: last line has too many segments");
}
if (seg->byte_count != 1)
{
- g_error ("gtk_text_btree_check: last line has wrong # characters: %d",
+ g_error ("_gtk_text_btree_check: last line has wrong # characters: %d",
seg->byte_count);
}
if ((seg->body.chars[0] != '\n') || (seg->body.chars[1] != 0))
{
- g_error ("gtk_text_btree_check: last line had bad value: %s",
+ g_error ("_gtk_text_btree_check: last line had bad value: %s",
seg->body.chars);
}
}
-void gtk_text_btree_spew_line (GtkTextBTree* tree, GtkTextLine* line);
-void gtk_text_btree_spew_segment (GtkTextBTree* tree, GtkTextLineSegment* seg);
-void gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent);
-void gtk_text_btree_spew_line_short (GtkTextLine *line, int indent);
+void _gtk_text_btree_spew_line (GtkTextBTree* tree, GtkTextLine* line);
+void _gtk_text_btree_spew_segment (GtkTextBTree* tree, GtkTextLineSegment* seg);
+void _gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent);
+void _gtk_text_btree_spew_line_short (GtkTextLine *line, int indent);
void
-gtk_text_btree_spew (GtkTextBTree *tree)
+_gtk_text_btree_spew (GtkTextBTree *tree)
{
GtkTextLine * line;
int real_line;
printf ("%d lines in tree %p\n",
- gtk_text_btree_line_count (tree), tree);
+ _gtk_text_btree_line_count (tree), tree);
- line = gtk_text_btree_get_line (tree, 0, &real_line);
+ line = _gtk_text_btree_get_line (tree, 0, &real_line);
while (line != NULL)
{
- gtk_text_btree_spew_line (tree, line);
- line = gtk_text_line_next (line);
+ _gtk_text_btree_spew_line (tree, line);
+ line = _gtk_text_line_next (line);
}
printf ("=================== Tag information\n");
printf ("=================== Tree nodes\n");
{
- gtk_text_btree_spew_node (tree->root_node, 0);
+ _gtk_text_btree_spew_node (tree->root_node, 0);
}
}
void
-gtk_text_btree_spew_line_short (GtkTextLine *line, int indent)
+_gtk_text_btree_spew_line_short (GtkTextLine *line, int indent)
{
gchar * spaces;
GtkTextLineSegment *seg;
printf ("%sline %p chars %d bytes %d\n",
spaces, line,
- gtk_text_line_char_count (line),
- gtk_text_line_byte_count (line));
+ _gtk_text_line_char_count (line),
+ _gtk_text_line_byte_count (line));
seg = line->segments;
while (seg != NULL)
}
void
-gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent)
+_gtk_text_btree_spew_node (GtkTextBTreeNode *node, int indent)
{
gchar * spaces;
GtkTextBTreeNode *iter;
iter = node->children.node;
while (iter != NULL)
{
- gtk_text_btree_spew_node (iter, indent + 2);
+ _gtk_text_btree_spew_node (iter, indent + 2);
iter = iter->next;
}
GtkTextLine *line = node->children.line;
while (line != NULL)
{
- gtk_text_btree_spew_line_short (line, indent + 2);
+ _gtk_text_btree_spew_line_short (line, indent + 2);
line = line->next;
}
}
void
-gtk_text_btree_spew_line (GtkTextBTree* tree, GtkTextLine* line)
+_gtk_text_btree_spew_line (GtkTextBTree* tree, GtkTextLine* line)
{
GtkTextLineSegment * seg;
printf ("%4d| line: %p parent: %p next: %p\n",
- gtk_text_line_get_number (line), line, line->parent, line->next);
+ _gtk_text_line_get_number (line), line, line->parent, line->next);
seg = line->segments;
while (seg != NULL)
{
- gtk_text_btree_spew_segment (tree, seg);
+ _gtk_text_btree_spew_segment (tree, seg);
seg = seg->next;
}
}
void
-gtk_text_btree_spew_segment (GtkTextBTree* tree, GtkTextLineSegment * seg)
+_gtk_text_btree_spew_segment (GtkTextBTree* tree, GtkTextLineSegment * seg)
{
printf (" segment: %p type: %s bytes: %d chars: %d\n",
seg, seg->type->name, seg->byte_count, seg->char_count);
extern "C" {
#endif /* __cplusplus */
-GtkTextBTree *gtk_text_btree_new (GtkTextTagTable *table,
- GtkTextBuffer *buffer);
-void gtk_text_btree_ref (GtkTextBTree *tree);
-void gtk_text_btree_unref (GtkTextBTree *tree);
-GtkTextBuffer *gtk_text_btree_get_buffer (GtkTextBTree *tree);
+GtkTextBTree *_gtk_text_btree_new (GtkTextTagTable *table,
+ GtkTextBuffer *buffer);
+void _gtk_text_btree_ref (GtkTextBTree *tree);
+void _gtk_text_btree_unref (GtkTextBTree *tree);
+GtkTextBuffer *_gtk_text_btree_get_buffer (GtkTextBTree *tree);
-guint gtk_text_btree_get_chars_changed_stamp (GtkTextBTree *tree);
-guint gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree);
-void gtk_text_btree_segments_changed (GtkTextBTree *tree);
+guint _gtk_text_btree_get_chars_changed_stamp (GtkTextBTree *tree);
+guint _gtk_text_btree_get_segments_changed_stamp (GtkTextBTree *tree);
+void _gtk_text_btree_segments_changed (GtkTextBTree *tree);
/* Indexable segment mutation */
-void gtk_text_btree_delete (GtkTextIter *start,
- GtkTextIter *end);
-void gtk_text_btree_insert (GtkTextIter *iter,
- const gchar *text,
- gint len);
-void gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
- GdkPixbuf *pixbuf);
+void _gtk_text_btree_delete (GtkTextIter *start,
+ GtkTextIter *end);
+void _gtk_text_btree_insert (GtkTextIter *iter,
+ const gchar *text,
+ gint len);
+void __gtk_text_btree_insert_pixbuf (GtkTextIter *iter,
+ GdkPixbuf *pixbuf);
-GtkTextChildAnchor* gtk_text_btree_create_child_anchor (GtkTextIter *iter);
+GtkTextChildAnchor* _gtk_text_btree_create_child_anchor (GtkTextIter *iter);
-void gtk_text_btree_unregister_child_anchor (GtkTextChildAnchor *anchor);
+void _gtk_text_btree_unregister_child_anchor (GtkTextChildAnchor *anchor);
/* View stuff */
-GtkTextLine *gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
- gpointer view_id,
- gint ypixel,
- gint *line_top_y);
-gint gtk_text_btree_find_line_top (GtkTextBTree *tree,
- GtkTextLine *line,
- gpointer view_id);
-void gtk_text_btree_add_view (GtkTextBTree *tree,
- GtkTextLayout *layout);
-void gtk_text_btree_remove_view (GtkTextBTree *tree,
- gpointer view_id);
-void gtk_text_btree_invalidate_region (GtkTextBTree *tree,
- const GtkTextIter *start,
- const GtkTextIter *end);
-void gtk_text_btree_get_view_size (GtkTextBTree *tree,
- gpointer view_id,
- gint *width,
- gint *height);
-gboolean gtk_text_btree_is_valid (GtkTextBTree *tree,
- gpointer view_id);
-gboolean gtk_text_btree_validate (GtkTextBTree *tree,
- gpointer view_id,
- gint max_pixels,
- gint *y,
- gint *old_height,
- gint *new_height);
-void gtk_text_btree_validate_line (GtkTextBTree *tree,
- GtkTextLine *line,
- gpointer view_id);
+GtkTextLine *_gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
+ gpointer view_id,
+ gint ypixel,
+ gint *line_top_y);
+gint _gtk_text_btree_find_line_top (GtkTextBTree *tree,
+ GtkTextLine *line,
+ gpointer view_id);
+void _gtk_text_btree_add_view (GtkTextBTree *tree,
+ GtkTextLayout *layout);
+void _gtk_text_btree_remove_view (GtkTextBTree *tree,
+ gpointer view_id);
+void _gtk_text_btree_invalidate_region (GtkTextBTree *tree,
+ const GtkTextIter *start,
+ const GtkTextIter *end);
+void _gtk_text_btree_get_view_size (GtkTextBTree *tree,
+ gpointer view_id,
+ gint *width,
+ gint *height);
+gboolean _gtk_text_btree_is_valid (GtkTextBTree *tree,
+ gpointer view_id);
+gboolean _gtk_text_btree_validate (GtkTextBTree *tree,
+ gpointer view_id,
+ gint max_pixels,
+ gint *y,
+ gint *old_height,
+ gint *new_height);
+void __gtk_text_btree_validate_line (GtkTextBTree *tree,
+ GtkTextLine *line,
+ gpointer view_id);
/* Tag */
-void gtk_text_btree_tag (const GtkTextIter *start,
- const GtkTextIter *end,
- GtkTextTag *tag,
- gboolean apply);
+void _gtk_text_btree_tag (const GtkTextIter *start,
+ const GtkTextIter *end,
+ GtkTextTag *tag,
+ gboolean apply);
/* "Getters" */
-GtkTextLine * gtk_text_btree_get_line (GtkTextBTree *tree,
- gint line_number,
- gint *real_line_number);
-GtkTextLine * gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
- gint char_index,
- gint *line_start_index,
- gint *real_char_index);
-GtkTextTag** gtk_text_btree_get_tags (const GtkTextIter *iter,
- gint *num_tags);
-gchar *gtk_text_btree_get_text (const GtkTextIter *start,
- const GtkTextIter *end,
- gboolean include_hidden,
- gboolean include_nonchars);
-gint gtk_text_btree_line_count (GtkTextBTree *tree);
-gint gtk_text_btree_char_count (GtkTextBTree *tree);
-gboolean gtk_text_btree_char_is_invisible (const GtkTextIter *iter);
+GtkTextLine * _gtk_text_btree_get_line (GtkTextBTree *tree,
+ gint line_number,
+ gint *real_line_number);
+GtkTextLine * __gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
+ gint char_index,
+ gint *line_start_index,
+ gint *real_char_index);
+GtkTextTag** _gtk_text_btree_get_tags (const GtkTextIter *iter,
+ gint *num_tags);
+gchar *_gtk_text_btree_get_text (const GtkTextIter *start,
+ const GtkTextIter *end,
+ gboolean include_hidden,
+ gboolean include_nonchars);
+gint _gtk_text_btree_line_count (GtkTextBTree *tree);
+gint _gtk_text_btree_char_count (GtkTextBTree *tree);
+gboolean _gtk_text_btree_char_is_invisible (const GtkTextIter *iter);
/* Get iterators (these are implemented in gtktextiter.c) */
-void gtk_text_btree_get_iter_at_char (GtkTextBTree *tree,
- GtkTextIter *iter,
- gint char_index);
-void gtk_text_btree_get_iter_at_line_char (GtkTextBTree *tree,
- GtkTextIter *iter,
- gint line_number,
- gint char_index);
-void gtk_text_btree_get_iter_at_line_byte (GtkTextBTree *tree,
- GtkTextIter *iter,
- gint line_number,
- gint byte_index);
-gboolean gtk_text_btree_get_iter_from_string (GtkTextBTree *tree,
- GtkTextIter *iter,
- const gchar *string);
-gboolean gtk_text_btree_get_iter_at_mark_name (GtkTextBTree *tree,
- GtkTextIter *iter,
- const gchar *mark_name);
-void gtk_text_btree_get_iter_at_mark (GtkTextBTree *tree,
- GtkTextIter *iter,
- GtkTextMark *mark);
-void gtk_text_btree_get_last_iter (GtkTextBTree *tree,
- GtkTextIter *iter);
-void gtk_text_btree_get_iter_at_line (GtkTextBTree *tree,
- GtkTextIter *iter,
- GtkTextLine *line,
- gint byte_offset);
-gboolean gtk_text_btree_get_iter_at_first_toggle (GtkTextBTree *tree,
- GtkTextIter *iter,
- GtkTextTag *tag);
-gboolean gtk_text_btree_get_iter_at_last_toggle (GtkTextBTree *tree,
- GtkTextIter *iter,
- GtkTextTag *tag);
-
-void gtk_text_btree_get_iter_at_child_anchor (GtkTextBTree *tree,
+void _gtk_text_btree_get_iter_at_char (GtkTextBTree *tree,
GtkTextIter *iter,
- GtkTextChildAnchor *anchor);
+ gint char_index);
+void __gtk_text_btree_get_iter_at_line_char (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ gint line_number,
+ gint char_index);
+void __gtk_text_btree_get_iter_at_line_byte (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ gint line_number,
+ gint byte_index);
+gboolean _gtk_text_btree_get_iter_from_string (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ const gchar *string);
+gboolean __gtk_text_btree_get_iter_at_mark_name (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ const gchar *mark_name);
+void _gtk_text_btree_get_iter_at_mark (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ GtkTextMark *mark);
+void _gtk_text_btree_get_last_iter (GtkTextBTree *tree,
+ GtkTextIter *iter);
+void _gtk_text_btree_get_iter_at_line (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ GtkTextLine *line,
+ gint byte_offset);
+gboolean _gtk_text_btree_get_iter_at_first_toggle (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ GtkTextTag *tag);
+gboolean _gtk_text_btree_get_iter_at_last_toggle (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ GtkTextTag *tag);
+
+void _gtk_text_btree_get_iter_at_child_anchor (GtkTextBTree *tree,
+ GtkTextIter *iter,
+ GtkTextChildAnchor *anchor);
/* Manipulate marks */
-GtkTextMark *gtk_text_btree_set_mark (GtkTextBTree *tree,
- GtkTextMark *existing_mark,
- const gchar *name,
- gboolean left_gravity,
- const GtkTextIter *index,
- gboolean should_exist);
-void gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
- const gchar *name);
-void gtk_text_btree_remove_mark (GtkTextBTree *tree,
- GtkTextMark *segment);
-gboolean gtk_text_btree_get_selection_bounds (GtkTextBTree *tree,
- GtkTextIter *start,
- GtkTextIter *end);
-void gtk_text_btree_place_cursor (GtkTextBTree *tree,
- const GtkTextIter *where);
-gboolean gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
- GtkTextMark *segment);
-gboolean gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
- GtkTextMark *segment);
-GtkTextMark *gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
- const gchar *name);
-GtkTextLine * gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
- GtkTextTag *tag);
-GtkTextLine * gtk_text_btree_last_could_contain_tag (GtkTextBTree *tree,
- GtkTextTag *tag);
+GtkTextMark *_gtk_text_btree_set_mark (GtkTextBTree *tree,
+ GtkTextMark *existing_mark,
+ const gchar *name,
+ gboolean left_gravity,
+ const GtkTextIter *index,
+ gboolean should_exist);
+void __gtk_text_btree_remove_mark_by_name (GtkTextBTree *tree,
+ const gchar *name);
+void _gtk_text_btree_remove_mark (GtkTextBTree *tree,
+ GtkTextMark *segment);
+gboolean _gtk_text_btree_get_selection_bounds (GtkTextBTree *tree,
+ GtkTextIter *start,
+ GtkTextIter *end);
+void _gtk_text_btree_place_cursor (GtkTextBTree *tree,
+ const GtkTextIter *where);
+gboolean _gtk_text_btree_mark_is_insert (GtkTextBTree *tree,
+ GtkTextMark *segment);
+gboolean _gtk_text_btree_mark_is_selection_bound (GtkTextBTree *tree,
+ GtkTextMark *segment);
+GtkTextMark *_gtk_text_btree_get_mark_by_name (GtkTextBTree *tree,
+ const gchar *name);
+GtkTextLine * _gtk_text_btree_first_could_contain_tag (GtkTextBTree *tree,
+ GtkTextTag *tag);
+GtkTextLine * _gtk_text_btree_last_could_contain_tag (GtkTextBTree *tree,
+ GtkTextTag *tag);
/* Lines */
};
-gint gtk_text_line_get_number (GtkTextLine *line);
-gboolean gtk_text_line_char_has_tag (GtkTextLine *line,
- GtkTextBTree *tree,
- gint char_in_line,
- GtkTextTag *tag);
-gboolean gtk_text_line_byte_has_tag (GtkTextLine *line,
- GtkTextBTree *tree,
- gint byte_in_line,
- GtkTextTag *tag);
-gboolean gtk_text_line_is_last (GtkTextLine *line,
- GtkTextBTree *tree);
-GtkTextLine * gtk_text_line_next (GtkTextLine *line);
-GtkTextLine * gtk_text_line_previous (GtkTextLine *line);
-void gtk_text_line_add_data (GtkTextLine *line,
- GtkTextLineData *data);
-gpointer gtk_text_line_remove_data (GtkTextLine *line,
- gpointer view_id);
-gpointer gtk_text_line_get_data (GtkTextLine *line,
- gpointer view_id);
-void gtk_text_line_invalidate_wrap (GtkTextLine *line,
- GtkTextLineData *ld);
-gint gtk_text_line_char_count (GtkTextLine *line);
-gint gtk_text_line_byte_count (GtkTextLine *line);
-gint gtk_text_line_char_index (GtkTextLine *line);
-GtkTextLineSegment *gtk_text_line_byte_to_segment (GtkTextLine *line,
- gint byte_offset,
- gint *seg_offset);
-GtkTextLineSegment *gtk_text_line_char_to_segment (GtkTextLine *line,
- gint char_offset,
- gint *seg_offset);
-void gtk_text_line_byte_locate (GtkTextLine *line,
- gint byte_offset,
- GtkTextLineSegment **segment,
- GtkTextLineSegment **any_segment,
- gint *seg_byte_offset,
- gint *line_byte_offset);
-void gtk_text_line_char_locate (GtkTextLine *line,
- gint char_offset,
- GtkTextLineSegment **segment,
- GtkTextLineSegment **any_segment,
- gint *seg_char_offset,
- gint *line_char_offset);
-void gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
- gint byte_offset,
- gint *line_char_offset,
- gint *seg_char_offset);
-void gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
- gint char_offset,
- gint *line_byte_offset,
- gint *seg_byte_offset);
-GtkTextLineSegment *gtk_text_line_byte_to_any_segment (GtkTextLine *line,
- gint byte_offset,
- gint *seg_offset);
-GtkTextLineSegment *gtk_text_line_char_to_any_segment (GtkTextLine *line,
- gint char_offset,
- gint *seg_offset);
-gint gtk_text_line_byte_to_char (GtkTextLine *line,
- gint byte_offset);
-gint gtk_text_line_char_to_byte (GtkTextLine *line,
- gint char_offset);
-GtkTextLine * gtk_text_line_next_could_contain_tag (GtkTextLine *line,
- GtkTextBTree *tree,
- GtkTextTag *tag);
-GtkTextLine * gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
- GtkTextBTree *tree,
- GtkTextTag *tag);
+gint _gtk_text_line_get_number (GtkTextLine *line);
+gboolean _gtk_text_line_char_has_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ gint char_in_line,
+ GtkTextTag *tag);
+gboolean _gtk_text_line_byte_has_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ gint byte_in_line,
+ GtkTextTag *tag);
+gboolean _gtk_text_line_is_last (GtkTextLine *line,
+ GtkTextBTree *tree);
+GtkTextLine * _gtk_text_line_next (GtkTextLine *line);
+GtkTextLine * _gtk_text_line_previous (GtkTextLine *line);
+void _gtk_text_line_add_data (GtkTextLine *line,
+ GtkTextLineData *data);
+gpointer _gtk_text_line_remove_data (GtkTextLine *line,
+ gpointer view_id);
+gpointer _gtk_text_line_get_data (GtkTextLine *line,
+ gpointer view_id);
+void _gtk_text_line_invalidate_wrap (GtkTextLine *line,
+ GtkTextLineData *ld);
+gint _gtk_text_line_char_count (GtkTextLine *line);
+gint _gtk_text_line_byte_count (GtkTextLine *line);
+gint _gtk_text_line_char_index (GtkTextLine *line);
+GtkTextLineSegment *_gtk_text_line_byte_to_segment (GtkTextLine *line,
+ gint byte_offset,
+ gint *seg_offset);
+GtkTextLineSegment *_gtk_text_line_char_to_segment (GtkTextLine *line,
+ gint char_offset,
+ gint *seg_offset);
+void _gtk_text_line_byte_locate (GtkTextLine *line,
+ gint byte_offset,
+ GtkTextLineSegment **segment,
+ GtkTextLineSegment **any_segment,
+ gint *seg_byte_offset,
+ gint *line_byte_offset);
+void _gtk_text_line_char_locate (GtkTextLine *line,
+ gint char_offset,
+ GtkTextLineSegment **segment,
+ GtkTextLineSegment **any_segment,
+ gint *seg_char_offset,
+ gint *line_char_offset);
+void __gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
+ gint byte_offset,
+ gint *line_char_offset,
+ gint *seg_char_offset);
+void __gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
+ gint char_offset,
+ gint *line_byte_offset,
+ gint *seg_byte_offset);
+GtkTextLineSegment *_gtk_text_line_byte_to_any_segment (GtkTextLine *line,
+ gint byte_offset,
+ gint *seg_offset);
+GtkTextLineSegment *_gtk_text_line_char_to_any_segment (GtkTextLine *line,
+ gint char_offset,
+ gint *seg_offset);
+gint _gtk_text_line_byte_to_char (GtkTextLine *line,
+ gint byte_offset);
+gint _gtk_text_line_char_to_byte (GtkTextLine *line,
+ gint char_offset);
+GtkTextLine * __gtk_text_line_next_could_contain_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ GtkTextTag *tag);
+GtkTextLine * __gtk_text_line_previous_could_contain_tag (GtkTextLine *line,
+ GtkTextBTree *tree,
+ GtkTextTag *tag);
/* Debug */
-void gtk_text_btree_check (GtkTextBTree *tree);
-void gtk_text_btree_spew (GtkTextBTree *tree);
-extern gboolean gtk_text_view_debug_btree;
+void _gtk_text_btree_check (GtkTextBTree *tree);
+void _gtk_text_btree_spew (GtkTextBTree *tree);
+extern gboolean _gtk_text_view_debug_btree;
/* ignore, exported only for gtktextsegment.c */
void _gtk_toggle_segment_check_func (GtkTextLineSegment *segPtr,
if (buffer->btree)
{
- gtk_text_btree_unref (buffer->btree);
+ _gtk_text_btree_unref (buffer->btree);
buffer->btree = NULL;
}
get_btree (GtkTextBuffer *buffer)
{
if (buffer->btree == NULL)
- buffer->btree = gtk_text_btree_new (gtk_text_buffer_get_tag_table (buffer),
+ buffer->btree = _gtk_text_btree_new (gtk_text_buffer_get_tag_table (buffer),
buffer);
return buffer->btree;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
- gtk_text_btree_insert (iter, text, len);
+ _gtk_text_btree_insert (iter, text, len);
gtk_signal_emit (GTK_OBJECT (buffer), signals[CHANGED]);
}
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
- gtk_text_btree_delete (start, end);
+ _gtk_text_btree_delete (start, end);
/* may have deleted the selection... */
gtk_text_buffer_update_primary_selection (buffer);
g_return_if_fail (iter != NULL);
g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
- gtk_text_btree_insert_pixbuf (iter, pixbuf);
+ __gtk_text_btree_insert_pixbuf (iter, pixbuf);
/* FIXME pixbuf-specific signal like insert_text */
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (iter != NULL, NULL);
- anchor = gtk_text_btree_create_child_anchor (iter);
+ anchor = _gtk_text_btree_create_child_anchor (iter);
/* FIXME child-anchor-specific signal */
GtkTextIter location;
GtkTextMark *mark;
- mark = gtk_text_btree_set_mark (get_btree (buffer),
+ mark = _gtk_text_btree_set_mark (get_btree (buffer),
existing_mark,
mark_name,
left_gravity,
iter,
should_exist);
- if (gtk_text_btree_mark_is_insert (get_btree (buffer), mark) ||
- gtk_text_btree_mark_is_selection_bound (get_btree (buffer), mark))
+ if (_gtk_text_btree_mark_is_insert (get_btree (buffer), mark) ||
+ _gtk_text_btree_mark_is_selection_bound (get_btree (buffer), mark))
{
gtk_text_buffer_update_primary_selection (buffer);
}
- gtk_text_btree_get_iter_at_mark (get_btree (buffer),
+ _gtk_text_btree_get_iter_at_mark (get_btree (buffer),
&location,
mark);
g_return_if_fail (!gtk_text_mark_get_deleted (mark));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- gtk_text_btree_get_iter_at_mark (get_btree (buffer),
+ _gtk_text_btree_get_iter_at_mark (get_btree (buffer),
iter,
mark);
}
g_object_ref (G_OBJECT (mark));
- gtk_text_btree_remove_mark (get_btree (buffer), mark);
+ _gtk_text_btree_remove_mark (get_btree (buffer), mark);
/* See rationale above for MARK_SET on why we emit this after
* removing the mark, rather than removing the mark in a default
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (name != NULL, NULL);
- mark = gtk_text_btree_get_mark_by_name (get_btree (buffer), name);
+ mark = _gtk_text_btree_get_mark_by_name (get_btree (buffer), name);
return mark;
}
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (name != NULL);
- mark = gtk_text_btree_get_mark_by_name (get_btree (buffer), name);
+ mark = _gtk_text_btree_get_mark_by_name (get_btree (buffer), name);
if (mark == NULL)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (name != NULL);
- mark = gtk_text_btree_get_mark_by_name (get_btree (buffer), name);
+ mark = _gtk_text_btree_get_mark_by_name (get_btree (buffer), name);
if (mark == NULL)
{
g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
g_return_if_fail (!gtk_text_child_anchor_get_deleted (anchor));
- gtk_text_btree_get_iter_at_child_anchor (get_btree (buffer),
+ _gtk_text_btree_get_iter_at_child_anchor (get_btree (buffer),
iter,
anchor);
}
if (gtk_text_iter_is_last (&real))
gtk_text_iter_backward_char (&real);
- gtk_text_btree_place_cursor (get_btree (buffer), &real);
+ _gtk_text_btree_place_cursor (get_btree (buffer), &real);
gtk_text_buffer_mark_set (buffer, &real,
gtk_text_buffer_get_mark (buffer,
"insert"));
const GtkTextIter *start,
const GtkTextIter *end)
{
- gtk_text_btree_tag (start, end, tag, TRUE);
+ _gtk_text_btree_tag (start, end, tag, TRUE);
}
static void
const GtkTextIter *start,
const GtkTextIter *end)
{
- gtk_text_btree_tag (start, end, tag, FALSE);
+ _gtk_text_btree_tag (start, end, tag, FALSE);
}
static void
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- gtk_text_btree_get_iter_at_line_char (get_btree (buffer),
+ __gtk_text_btree_get_iter_at_line_char (get_btree (buffer),
iter, line_number, char_offset);
}
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- gtk_text_btree_get_iter_at_line_byte (get_btree (buffer),
+ __gtk_text_btree_get_iter_at_line_byte (get_btree (buffer),
iter, line_number, byte_index);
}
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- gtk_text_btree_get_iter_at_char (get_btree (buffer), iter, char_offset);
+ _gtk_text_btree_get_iter_at_char (get_btree (buffer), iter, char_offset);
}
void
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- gtk_text_btree_get_last_iter (get_btree (buffer), iter);
+ _gtk_text_btree_get_last_iter (get_btree (buffer), iter);
}
void
g_return_if_fail (end != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
- gtk_text_btree_get_iter_at_char (get_btree (buffer), start, 0);
- gtk_text_btree_get_last_iter (get_btree (buffer), end);
+ _gtk_text_btree_get_iter_at_char (get_btree (buffer), start, 0);
+ _gtk_text_btree_get_last_iter (get_btree (buffer), end);
}
/*
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), 0);
- return gtk_text_btree_line_count (get_btree (buffer));
+ return _gtk_text_btree_line_count (get_btree (buffer));
}
gint
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), 0);
- return gtk_text_btree_char_count (get_btree (buffer));
+ return _gtk_text_btree_char_count (get_btree (buffer));
}
/* Called when we lose the primary selection.
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
- return gtk_text_btree_get_selection_bounds (get_btree (buffer), start, end);
+ return _gtk_text_btree_get_selection_bounds (get_btree (buffer), start, end);
}
/*
{
buffer->log_attr_cache = g_new0 (GtkTextLogAttrCache, 1);
buffer->log_attr_cache->chars_changed_stamp =
- gtk_text_btree_get_chars_changed_stamp (get_btree (buffer));
+ _gtk_text_btree_get_chars_changed_stamp (get_btree (buffer));
}
else if (buffer->log_attr_cache->chars_changed_stamp !=
- gtk_text_btree_get_chars_changed_stamp (get_btree (buffer)))
+ _gtk_text_btree_get_chars_changed_stamp (get_btree (buffer)))
{
clear_log_attr_cache (buffer->log_attr_cache);
}
void
_gtk_text_buffer_spew (GtkTextBuffer *buffer)
{
- gtk_text_btree_spew (get_btree (buffer));
+ _gtk_text_btree_spew (get_btree (buffer));
}
GSList *tmp_list;
GSList *copy;
- gtk_text_btree_unregister_child_anchor (seg->body.child.obj);
+ _gtk_text_btree_unregister_child_anchor (seg->body.child.obj);
seg->body.child.tree = NULL;
seg->body.child.line = NULL;
if (have_selection)
{
GtkTextIter line_start, line_end;
- gint byte_count = gtk_text_line_byte_count (line);
+ gint byte_count = _gtk_text_line_byte_count (line);
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
&line_start,
line, 0);
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
&line_end,
line, byte_count - 1);
{
/* Update segments stamp */
iter->segments_changed_stamp =
- gtk_text_btree_get_segments_changed_stamp (iter->tree);
+ _gtk_text_btree_get_segments_changed_stamp (iter->tree);
iter->line = line;
{
iter_set_common (iter, line);
- gtk_text_line_byte_locate (iter->line,
+ _gtk_text_line_byte_locate (iter->line,
byte_offset,
&iter->segment,
&iter->any_segment,
{
iter_set_common (iter, line);
- gtk_text_line_char_locate (iter->line,
+ _gtk_text_line_char_locate (iter->line,
char_offset,
&iter->segment,
&iter->any_segment,
GtkTextRealIter *iter = (GtkTextRealIter*)_iter;
if (iter->chars_changed_stamp !=
- gtk_text_btree_get_chars_changed_stamp (iter->tree))
+ _gtk_text_btree_get_chars_changed_stamp (iter->tree))
{
g_warning ("Invalid text buffer iterator: either the iterator "
"is uninitialized, or the characters/pixbufs/widgets "
should have used make_real. */
if (iter->segments_changed_stamp !=
- gtk_text_btree_get_segments_changed_stamp (iter->tree))
+ _gtk_text_btree_get_segments_changed_stamp (iter->tree))
{
iter->segment = NULL;
iter->any_segment = NULL;
iter = gtk_text_iter_make_surreal (_iter);
if (iter->segments_changed_stamp !=
- gtk_text_btree_get_segments_changed_stamp (iter->tree))
+ _gtk_text_btree_get_segments_changed_stamp (iter->tree))
{
if (iter->line_byte_offset >= 0)
{
iter->tree = tree;
iter->chars_changed_stamp =
- gtk_text_btree_get_chars_changed_stamp (iter->tree);
+ _gtk_text_btree_get_chars_changed_stamp (iter->tree);
return iter;
}
{
g_assert (iter->line_byte_offset >= 0);
- gtk_text_line_byte_to_char_offsets (iter->line,
+ __gtk_text_line_byte_to_char_offsets (iter->line,
iter->line_byte_offset,
&iter->line_char_offset,
&iter->segment_char_offset);
{
g_assert (iter->line_char_offset >= 0);
- gtk_text_line_char_to_byte_offsets (iter->line,
+ __gtk_text_line_char_to_byte_offsets (iter->line,
iter->line_char_offset,
&iter->line_byte_offset,
&iter->segment_byte_offset);
check_invariants (iter);
- return gtk_text_btree_get_buffer (real->tree);
+ return _gtk_text_btree_get_buffer (real->tree);
}
/**
ensure_char_offsets (real);
real->cached_char_index =
- gtk_text_line_char_index (real->line);
+ _gtk_text_line_char_index (real->line);
real->cached_char_index += real->line_char_offset;
}
if (real->cached_line_number < 0)
real->cached_line_number =
- gtk_text_line_get_number (real->line);
+ _gtk_text_line_get_number (real->line);
check_invariants (iter);
check_invariants (start);
check_invariants (end);
- return gtk_text_btree_get_text (start, end, TRUE, TRUE);
+ return _gtk_text_btree_get_text (start, end, TRUE, TRUE);
}
/**
check_invariants (start);
check_invariants (end);
- return gtk_text_btree_get_text (start, end, TRUE, FALSE);
+ return _gtk_text_btree_get_text (start, end, TRUE, FALSE);
}
/**
check_invariants (start);
check_invariants (end);
- return gtk_text_btree_get_text (start, end, FALSE, TRUE);
+ return _gtk_text_btree_get_text (start, end, FALSE, TRUE);
}
/**
check_invariants (start);
check_invariants (end);
- return gtk_text_btree_get_text (start, end, FALSE, FALSE);
+ return _gtk_text_btree_get_text (start, end, FALSE, FALSE);
}
/**
if (real->line_byte_offset >= 0)
{
- return gtk_text_line_byte_has_tag (real->line, real->tree,
+ return _gtk_text_line_byte_has_tag (real->line, real->tree,
real->line_byte_offset, tag);
}
else
{
g_assert (real->line_char_offset >= 0);
- return gtk_text_line_char_has_tag (real->line, real->tree,
+ return _gtk_text_line_char_has_tag (real->line, real->tree,
real->line_char_offset, tag);
}
}
g_return_val_if_fail (iter != NULL, NULL);
/* Get the tags at this spot */
- tags = gtk_text_btree_get_tags (iter, &tag_count);
+ tags = _gtk_text_btree_get_tags (iter, &tag_count);
/* No tags, use default style */
if (tags == NULL || tag_count == 0)
check_invariants (iter);
- return gtk_text_line_is_last (real->line, real->tree);
+ return _gtk_text_line_is_last (real->line, real->tree);
}
/**
gint tag_count = 0;
/* Get the tags at this spot */
- tags = gtk_text_btree_get_tags (iter, &tag_count);
+ tags = _gtk_text_btree_get_tags (iter, &tag_count);
/* No tags, use default style */
if (tags == NULL || tag_count == 0)
{
GtkTextLine *new_line;
- new_line = gtk_text_line_next (real->line);
+ new_line = _gtk_text_line_next (real->line);
g_assert (new_line != real->line);
line at the end is a single char segment containing
a newline. */
if (real->segments_changed_stamp ==
- gtk_text_btree_get_segments_changed_stamp (real->tree))
+ _gtk_text_btree_get_segments_changed_stamp (real->tree))
{
g_assert (real->segment->type == >k_text_char_type);
g_assert (real->segment->char_count == 1);
{
GtkTextLine *new_line;
- new_line = gtk_text_line_previous (real->line);
+ new_line = _gtk_text_line_previous (real->line);
g_assert (new_line != real->line);
current_char_index = gtk_text_iter_get_offset (iter);
- if (current_char_index == gtk_text_btree_char_count (real->tree))
+ if (current_char_index == _gtk_text_btree_char_count (real->tree))
return FALSE; /* can't move forward */
new_char_index = current_char_index + count;
check_invariants (iter);
- new_line = gtk_text_line_previous (real->line);
+ new_line = _gtk_text_line_previous (real->line);
offset_will_change = FALSE;
if (real->line_char_offset > 0)
/* Find first segment in line */
real->any_segment = real->line->segments;
- real->segment = gtk_text_line_byte_to_segment (real->line,
+ real->segment = _gtk_text_line_byte_to_segment (real->line,
0, &offset);
g_assert (offset == 0);
check_invariants (iter);
- line = gtk_text_btree_get_line (real->tree, line_number, &real_line);
+ line = _gtk_text_btree_get_line (real->tree, line_number, &real_line);
iter_set_from_char_offset (real, line, 0);
real->cached_char_index == char_index)
return;
- line = gtk_text_btree_get_line_at_char (real->tree,
+ line = __gtk_text_btree_get_line_at_char (real->tree,
char_index,
&line_start,
&real_char_index);
if (real == NULL)
return;
- buffer = gtk_text_btree_get_buffer (real->tree);
+ buffer = _gtk_text_btree_get_buffer (real->tree);
gtk_text_buffer_get_last_iter (buffer, iter);
}
check_invariants (iter);
current_line = real->line;
- next_line = gtk_text_line_next_could_contain_tag (current_line,
+ next_line = __gtk_text_line_next_could_contain_tag (current_line,
real->tree, tag);
while (gtk_text_iter_forward_indexable_segment (iter))
if (next_line == NULL)
{
/* End of search. Set to end of buffer. */
- gtk_text_btree_get_last_iter (real->tree, iter);
+ _gtk_text_btree_get_last_iter (real->tree, iter);
return FALSE;
}
iter_set_from_byte_offset (real, next_line, 0);
current_line = real->line;
- next_line = gtk_text_line_next_could_contain_tag (current_line,
+ next_line = __gtk_text_line_next_could_contain_tag (current_line,
real->tree,
tag);
}
check_invariants (iter);
current_line = real->line;
- prev_line = gtk_text_line_previous_could_contain_tag (current_line,
+ prev_line = __gtk_text_line_previous_could_contain_tag (current_line,
real->tree, tag);
if (prev_line == NULL)
{
/* End of search. Set to start of buffer. */
- gtk_text_btree_get_iter_at_char (real->tree, iter, 0);
+ _gtk_text_btree_get_iter_at_char (real->tree, iter, 0);
return FALSE;
}
}
current_line = real->line;
- prev_line = gtk_text_line_previous_could_contain_tag (current_line,
+ prev_line = __gtk_text_line_previous_could_contain_tag (current_line,
real->tree,
tag);
}
if (!ignored &&
skip_invisible &&
- gtk_text_btree_char_is_invisible (iter))
+ _gtk_text_btree_char_is_invisible (iter))
ignored = TRUE;
gtk_text_iter_forward_char (iter);
*/
void
-gtk_text_btree_get_iter_at_char (GtkTextBTree *tree,
+_gtk_text_btree_get_iter_at_char (GtkTextBTree *tree,
GtkTextIter *iter,
gint char_index)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (tree != NULL);
- line = gtk_text_btree_get_line_at_char (tree, char_index,
+ line = __gtk_text_btree_get_line_at_char (tree, char_index,
&line_start, &real_char_index);
iter_init_from_char_offset (iter, tree, line, real_char_index - line_start);
}
void
-gtk_text_btree_get_iter_at_line_char (GtkTextBTree *tree,
+__gtk_text_btree_get_iter_at_line_char (GtkTextBTree *tree,
GtkTextIter *iter,
gint line_number,
gint char_on_line)
g_return_if_fail (iter != NULL);
g_return_if_fail (tree != NULL);
- line = gtk_text_btree_get_line (tree, line_number, &real_line);
+ line = _gtk_text_btree_get_line (tree, line_number, &real_line);
iter_init_from_char_offset (iter, tree, line, char_on_line);
}
void
-gtk_text_btree_get_iter_at_line_byte (GtkTextBTree *tree,
+__gtk_text_btree_get_iter_at_line_byte (GtkTextBTree *tree,
GtkTextIter *iter,
gint line_number,
gint byte_index)
g_return_if_fail (iter != NULL);
g_return_if_fail (tree != NULL);
- line = gtk_text_btree_get_line (tree, line_number, &real_line);
+ line = _gtk_text_btree_get_line (tree, line_number, &real_line);
iter_init_from_byte_offset (iter, tree, line, byte_index);
}
void
-gtk_text_btree_get_iter_at_line (GtkTextBTree *tree,
+_gtk_text_btree_get_iter_at_line (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextLine *line,
gint byte_offset)
}
gboolean
-gtk_text_btree_get_iter_at_first_toggle (GtkTextBTree *tree,
+_gtk_text_btree_get_iter_at_first_toggle (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextTag *tag)
{
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (tree != NULL, FALSE);
- line = gtk_text_btree_first_could_contain_tag (tree, tag);
+ line = _gtk_text_btree_first_could_contain_tag (tree, tag);
if (line == NULL)
{
/* Set iter to last in tree */
- gtk_text_btree_get_last_iter (tree, iter);
+ _gtk_text_btree_get_last_iter (tree, iter);
check_invariants (iter);
return FALSE;
}
}
gboolean
-gtk_text_btree_get_iter_at_last_toggle (GtkTextBTree *tree,
+_gtk_text_btree_get_iter_at_last_toggle (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextTag *tag)
{
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (tree != NULL, FALSE);
- line = gtk_text_btree_last_could_contain_tag (tree, tag);
+ line = _gtk_text_btree_last_could_contain_tag (tree, tag);
if (line == NULL)
{
/* Set iter to first in tree */
- gtk_text_btree_get_iter_at_line_char (tree, iter, 0, 0);
+ __gtk_text_btree_get_iter_at_line_char (tree, iter, 0, 0);
check_invariants (iter);
return FALSE;
}
}
gboolean
-gtk_text_btree_get_iter_at_mark_name (GtkTextBTree *tree,
+__gtk_text_btree_get_iter_at_mark_name (GtkTextBTree *tree,
GtkTextIter *iter,
const gchar *mark_name)
{
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (tree != NULL, FALSE);
- mark = gtk_text_btree_get_mark_by_name (tree, mark_name);
+ mark = _gtk_text_btree_get_mark_by_name (tree, mark_name);
if (mark == NULL)
return FALSE;
else
{
- gtk_text_btree_get_iter_at_mark (tree, iter, mark);
+ _gtk_text_btree_get_iter_at_mark (tree, iter, mark);
check_invariants (iter);
return TRUE;
}
}
void
-gtk_text_btree_get_iter_at_mark (GtkTextBTree *tree,
+_gtk_text_btree_get_iter_at_mark (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextMark *mark)
{
}
void
-gtk_text_btree_get_iter_at_child_anchor (GtkTextBTree *tree,
+_gtk_text_btree_get_iter_at_child_anchor (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextChildAnchor *anchor)
{
}
void
-gtk_text_btree_get_last_iter (GtkTextBTree *tree,
+_gtk_text_btree_get_last_iter (GtkTextBTree *tree,
GtkTextIter *iter)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (tree != NULL);
- gtk_text_btree_get_iter_at_char (tree,
+ _gtk_text_btree_get_iter_at_char (tree,
iter,
- gtk_text_btree_char_count (tree));
+ _gtk_text_btree_char_count (tree));
check_invariants (iter);
}
g_return_if_fail (iter != NULL);
- if (real->chars_changed_stamp != gtk_text_btree_get_chars_changed_stamp (real->tree))
+ if (real->chars_changed_stamp != _gtk_text_btree_get_chars_changed_stamp (real->tree))
g_print (" %20s: <invalidated iterator>\n", desc);
else
{
g_assert (sizeof (GtkTextIter) == sizeof (GtkTextRealIter));
if (real->chars_changed_stamp !=
- gtk_text_btree_get_chars_changed_stamp (real->tree))
+ _gtk_text_btree_get_chars_changed_stamp (real->tree))
g_error ("iterator check failed: invalid iterator");
if (real->line_char_offset < 0 && real->line_byte_offset < 0)
g_error ("iterator check failed: both char and byte offsets are invalid");
segments_updated = (real->segments_changed_stamp ==
- gtk_text_btree_get_segments_changed_stamp (real->tree));
+ _gtk_text_btree_get_segments_changed_stamp (real->tree));
#if 0
printf ("checking iter, segments %s updated, byte %d char %d\n",
if (real->line_byte_offset >= 0)
{
- gtk_text_line_byte_locate (real->line, real->line_byte_offset,
+ _gtk_text_line_byte_locate (real->line, real->line_byte_offset,
&byte_segment, &byte_any_segment,
&seg_byte_offset, &line_byte_offset);
if (real->line_char_offset >= 0)
{
- gtk_text_line_char_locate (real->line, real->line_char_offset,
+ _gtk_text_line_char_locate (real->line, real->line_char_offset,
&char_segment, &char_any_segment,
&seg_char_offset, &line_char_offset);
{
gint should_be;
- should_be = gtk_text_line_get_number (real->line);
+ should_be = _gtk_text_line_get_number (real->line);
if (real->cached_line_number != should_be)
g_error ("wrong line number was cached");
}
{
gint char_index;
- char_index = gtk_text_line_char_index (real->line);
+ char_index = _gtk_text_line_char_index (real->line);
char_index += real->line_char_offset;
if (real->cached_char_index != char_index)
if (layout->buffer)
{
- gtk_text_btree_remove_view (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_remove_view (_gtk_text_buffer_get_btree (layout->buffer),
layout);
gtk_object_unref (GTK_OBJECT (layout->buffer));
gtk_object_sink (GTK_OBJECT (buffer));
gtk_object_ref (GTK_OBJECT (buffer));
- gtk_text_btree_add_view (_gtk_text_buffer_get_btree (buffer), layout);
+ _gtk_text_btree_add_view (_gtk_text_buffer_get_btree (buffer), layout);
}
}
gtk_text_buffer_get_mark (layout->buffer, "insert"));
line = gtk_text_iter_get_text_line (&iter);
- line_data = gtk_text_line_get_data (line, layout);
+ line_data = _gtk_text_line_get_data (line, layout);
if (line_data)
{
gtk_text_layout_invalidate_cache (layout, line);
- gtk_text_line_invalidate_wrap (line, line_data);
+ _gtk_text_line_invalidate_wrap (line, line_data);
gtk_text_layout_invalidated (layout);
}
}
retval = NULL;
first_btree_line =
- gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
layout, top_y, first_line_y);
if (first_btree_line == NULL)
{
/* -1 since bottom_y is one past */
last_btree_line =
- gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
layout, bottom_y - 1, NULL);
if (!last_btree_line)
last_btree_line =
- gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
- gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1,
+ _gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1,
NULL);
{
- GtkTextLineData *ld = gtk_text_line_get_data (last_btree_line, layout);
+ GtkTextLineData *ld = _gtk_text_line_get_data (last_btree_line, layout);
if (ld->height == 0)
G_BREAKPOINT ();
}
if (line == last_btree_line)
break;
- line = gtk_text_line_next (line);
+ line = _gtk_text_line_next (line);
}
retval = g_slist_reverse (retval);
while (TRUE)
{
- GtkTextLineData *line_data = gtk_text_line_get_data (line, layout);
+ GtkTextLineData *line_data = _gtk_text_line_get_data (line, layout);
if (line_data &&
(line != last_line || !gtk_text_iter_starts_line (end)))
{
gtk_text_layout_invalidate_cache (layout, line);
- gtk_text_line_invalidate_wrap (line, line_data);
+ _gtk_text_line_invalidate_wrap (line, line_data);
}
if (line == last_line)
break;
- line = gtk_text_line_next (line);
+ line = _gtk_text_line_next (line);
}
gtk_text_layout_invalidated (layout);
g_return_val_if_fail (layout != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TEXT_LAYOUT (layout), FALSE);
- return gtk_text_btree_is_valid (_gtk_text_buffer_get_btree (layout->buffer),
+ return _gtk_text_btree_is_valid (_gtk_text_buffer_get_btree (layout->buffer),
layout);
}
static void
update_layout_size (GtkTextLayout *layout)
{
- gtk_text_btree_get_view_size (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_view_size (_gtk_text_buffer_get_btree (layout->buffer),
layout,
&layout->width, &layout->height);
}
seen = 0;
while (line && seen < -y0)
{
- GtkTextLineData *line_data = gtk_text_line_get_data (line, layout);
+ GtkTextLineData *line_data = _gtk_text_line_get_data (line, layout);
if (!line_data || !line_data->valid)
{
gint old_height = line_data ? line_data->height : 0;
- gtk_text_btree_validate_line (_gtk_text_buffer_get_btree (layout->buffer),
+ __gtk_text_btree_validate_line (_gtk_text_buffer_get_btree (layout->buffer),
line, layout);
- line_data = gtk_text_line_get_data (line, layout);
+ line_data = _gtk_text_line_get_data (line, layout);
delta_height += line_data->height - old_height;
}
seen += line_data->height;
- line = gtk_text_line_previous (line);
+ line = _gtk_text_line_previous (line);
}
/* Validate forwards to y1 */
seen = 0;
while (line && seen < y1)
{
- GtkTextLineData *line_data = gtk_text_line_get_data (line, layout);
+ GtkTextLineData *line_data = _gtk_text_line_get_data (line, layout);
if (!line_data || !line_data->valid)
{
gint old_height = line_data ? line_data->height : 0;
- gtk_text_btree_validate_line (_gtk_text_buffer_get_btree (layout->buffer),
+ __gtk_text_btree_validate_line (_gtk_text_buffer_get_btree (layout->buffer),
line, layout);
- line_data = gtk_text_line_get_data (line, layout);
+ line_data = _gtk_text_line_get_data (line, layout);
delta_height += line_data->height - old_height;
}
seen += line_data->height;
- line = gtk_text_line_next (line);
+ line = _gtk_text_line_next (line);
}
/* If we found and validated any invalid lines, update size and
update_layout_size (layout);
- line_top = gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
+ line_top = _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
first_line, layout);
gtk_text_layout_changed (layout,
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
while (max_pixels > 0 &&
- gtk_text_btree_validate (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_validate (_gtk_text_buffer_get_btree (layout->buffer),
layout, max_pixels,
&y, &old_height, &new_height))
{
if (line_data == NULL)
{
line_data = gtk_text_line_data_new (layout, line);
- gtk_text_line_add_data (line, line_data);
+ _gtk_text_line_add_data (line, line_data);
}
display = gtk_text_layout_get_line_display (layout, line, TRUE);
g_assert (layout->one_style_cache == NULL);
/* Get the tags at this spot */
- tags = gtk_text_btree_get_tags (iter, &tag_count);
+ tags = _gtk_text_btree_get_tags (iter, &tag_count);
/* No tags, use default style */
if (tags == NULL || tag_count == 0)
function can use the whole btree to get it right. */
else
{
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
iter, line, 0);
- if (!gtk_text_btree_char_is_invisible (iter))
+ if (!_gtk_text_btree_char_is_invisible (iter))
return FALSE;
}
/* Hide insertion cursor when we have a selection or the layout
* user has hidden the cursor.
*/
- if (gtk_text_btree_mark_is_insert (_gtk_text_buffer_get_btree (layout->buffer),
+ if (_gtk_text_btree_mark_is_insert (_gtk_text_buffer_get_btree (layout->buffer),
seg->body.mark.obj) &&
(!layout->cursor_visible ||
gtk_text_buffer_get_selection_bounds (layout->buffer, NULL, NULL)))
display->line = line;
display->insert_index = -1;
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
&iter, line, 0);
/* Special-case optimization for completely
/* Allocate space for flat text for buffer
*/
- byte_count = gtk_text_line_byte_count (line);
+ byte_count = _gtk_text_line_byte_count (line);
text = g_malloc (byte_count);
attrs = pango_attr_list_new ();
seg->type == >k_text_pixbuf_type ||
seg->type == >k_text_child_type)
{
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
&iter, line,
byte_offset);
style = get_style (layout, &iter);
*/
if (layout->preedit_len > 0 &&
- gtk_text_btree_mark_is_insert (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_mark_is_insert (_gtk_text_buffer_get_btree (layout->buffer),
seg->body.mark.obj))
break;
/* At the insertion point, add the preedit string, if any */
- if (gtk_text_btree_mark_is_insert (_gtk_text_buffer_get_btree (layout->buffer),
+ if (_gtk_text_btree_mark_is_insert (_gtk_text_buffer_get_btree (layout->buffer),
seg->body.mark.obj))
{
display->insert_index = byte_offset;
trailing = 0;
}
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
iter, display->line, index);
gtk_text_iter_forward_chars (iter, trailing);
}
if (y > layout->height)
y = layout->height;
- *line = gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
+ *line = _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
layout, y, line_top);
if (*line == NULL)
{
- *line = gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
- gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1, NULL);
+ *line = _gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1, NULL);
if (line_top)
*line_top =
- gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
*line, layout);
}
}
g_return_if_fail (target_iter != NULL);
get_line_at_y (layout, y, &line, line_top);
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
target_iter, line, 0);
}
if (!pango_layout_xy_to_index (display->layout, x * PANGO_SCALE, y * PANGO_SCALE,
&byte_index, &trailing))
{
- byte_index = gtk_text_line_byte_count (line);
+ byte_index = _gtk_text_line_byte_count (line);
trailing = 0;
}
display = gtk_text_layout_get_line_display (layout, line, FALSE);
index = line_display_iter_to_index (layout, display, iter);
- line_top = gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
+ line_top = _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
line, layout);
pango_layout_get_cursor_pos (display->layout, index,
line = gtk_text_iter_get_text_line (iter);
if (y)
- *y = gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
+ *y = _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
line, layout);
if (height)
{
- GtkTextLineData *line_data = gtk_text_line_get_data (line, layout);
+ GtkTextLineData *line_data = _gtk_text_line_get_data (line, layout);
if (line_data)
*height = line_data->height;
else
display = gtk_text_layout_get_line_display (layout, line, FALSE);
- rect->y = gtk_text_btree_find_line_top (tree, line, layout);
+ rect->y = _gtk_text_btree_find_line_top (tree, line, layout);
x_offset = display->x_offset * PANGO_SCALE;
gint line_top;
gint found_byte = 0;
- line = gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
+ line = _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
layout, y, &line_top);
if (!line)
{
line =
- gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
- gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1,
+ _gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1,
NULL);
line_top =
- gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
line, layout);
}
line_top += display->bottom_margin;
gtk_text_layout_free_line_display (layout, display);
- next = gtk_text_line_next (line);
+ next = _gtk_text_line_next (line);
if (!next)
found_line = line;
line = next;
}
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
iter, found_line, found_byte);
}
gint line_top;
gint found_byte = 0;
- line = gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer), layout, y, &line_top);
+ line = _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer), layout, y, &line_top);
if (!line)
{
- line = gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
- gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1, NULL);
- line_top = gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer), line, layout);
+ line = _gtk_text_btree_get_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_line_count (_gtk_text_buffer_get_btree (layout->buffer)) - 1, NULL);
+ line_top = _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer), line, layout);
}
while (line && !found_line)
gtk_text_layout_free_line_display (layout, display);
- line = gtk_text_line_previous (line);
+ line = _gtk_text_line_previous (line);
}
done:
if (found_line)
- gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
+ _gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
iter, found_line, found_byte);
else
gtk_text_buffer_get_iter_at_offset (layout->buffer, iter, 0);
if (line_byte < layout_line->length || !tmp_list->next) /* first line of paragraph */
{
- GtkTextLine *prev_line = gtk_text_line_previous (line);
+ GtkTextLine *prev_line = _gtk_text_line_previous (line);
if (prev_line)
{
gtk_text_layout_free_line_display (layout, display);
- line = gtk_text_line_next (line);
+ line = _gtk_text_line_next (line);
}
return
gint line_byte;
gint extra_back = 0;
- int byte_count = gtk_text_line_byte_count (line);
+ int byte_count = _gtk_text_line_byte_count (line);
int new_index;
int new_trailing;
if (new_index < 0 || (new_index == 0 && extra_back))
{
- line = gtk_text_line_previous (line);
+ line = _gtk_text_line_previous (line);
if (!line)
goto done;
gtk_text_layout_free_line_display (layout, display);
display = gtk_text_layout_get_line_display (layout, line, FALSE);
- new_index = gtk_text_line_byte_count (line);
+ new_index = _gtk_text_line_byte_count (line);
}
else if (new_index > byte_count)
{
- line = gtk_text_line_next (line);
+ line = _gtk_text_line_next (line);
if (!line)
goto done;
if (seg->body.mark.tree == NULL)
return NULL;
else
- return gtk_text_btree_get_buffer (seg->body.mark.tree);
+ return _gtk_text_btree_get_buffer (seg->body.mark.tree);
}
/*
g_assert (count != seg->byte_count);
g_assert (seg->byte_count > 0);
- gtk_text_btree_segments_changed (tree);
+ _gtk_text_btree_segments_changed (tree);
seg = (*seg->type->splitFunc)(seg, count);
projects / gtk4.git / commitdiff